Entity Relationships (One-to-One, One-to-Many, Many-to-Many)

Entity Relationship কী?

Entity Relationship হলো ডাটাবেসের টেবিলের মধ্যে সম্পর্ক, যা Spring Boot ORM (Hibernate/JPA) এর মাধ্যমে Java ক্লাসে উপস্থাপন করা হয়। এটি ডাটাবেসের টেবিলের রিলেশনশিপকে Java অবজেক্টের মধ্যে ম্যাপিং করতে ব্যবহৃত হয়।

Spring Boot ORM-এ মূলত তিন ধরনের Entity Relationship ব্যবহৃত হয়:

• One-to-One
• One-to-Many
• Many-to-Many

One-to-One সম্পর্ক

One-to-One সম্পর্ক বোঝায় যে একটি Entity একটি নির্দিষ্ট Entity এর সাথে শুধুমাত্র একটি সম্পর্কযুক্ত হতে পারে। উদাহরণস্বরূপ, একটি User এর একটি Profile থাকতে পারে।

উদাহরণ

Entity: User

import jakarta.persistence.*;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "profile_id", referencedColumnName = "id")
    private Profile profile;

    // Getters and Setters
}

Entity: Profile

import jakarta.persistence.*;

@Entity
public class Profile {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String bio;

    // Getters and Setters
}

One-to-Many সম্পর্ক

One-to-Many সম্পর্ক বোঝায় যে একটি Entity এর সাথে একাধিক Entity সম্পর্কিত হতে পারে। উদাহরণস্বরূপ, একটি Department এর অনেকগুলো Employee থাকতে পারে।

উদাহরণ

Entity: Department

import jakarta.persistence.*;
import java.util.List;

@Entity
public class Department {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @OneToMany(mappedBy = "department", cascade = CascadeType.ALL)
    private List<Employee> employees;

    // Getters and Setters
}

Entity: Employee

import jakarta.persistence.*;

@Entity
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @ManyToOne
    @JoinColumn(name = "department_id", nullable = false)
    private Department department;

    // Getters and Setters
}

Many-to-Many সম্পর্ক

Many-to-Many সম্পর্ক বোঝায় যে একাধিক Entity একাধিক Entity এর সাথে সম্পর্কযুক্ত হতে পারে। উদাহরণস্বরূপ, একজন Student অনেক Course এ এনরোল হতে পারে এবং একটি Course তে অনেক Student থাকতে পারে।

উদাহরণ

Entity: Student

import jakarta.persistence.*;
import java.util.Set;

@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @ManyToMany
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private Set<Course> courses;

    // Getters and Setters
}

Entity: Course

import jakarta.persistence.*;
import java.util.Set;

@Entity
public class Course {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;

    @ManyToMany(mappedBy = "courses")
    private Set<Student> students;

    // Getters and Setters
}

Cascade এবং Fetch টাইপের ভূমিকা

Cascade

Cascade বোঝায় একটি Entity এর অপারেশন (Save, Delete) এর সাথে সম্পর্কিত Entity গুলোর ওপর একই অপারেশন প্রয়োগ হবে। উদাহরণ:

• CascadeType.ALL: সব অপারেশন প্রয়োগ হয়।
• CascadeType.PERSIST: শুধুমাত্র Save অপারেশন।
• CascadeType.REMOVE: শুধুমাত্র Delete অপারেশন।

Fetch Type

Fetch টাইপ নির্ধারণ করে কিভাবে সম্পর্কিত Entity ডেটা লোড হবে।

• FetchType.LAZY: ডেটা প্রয়োজন হলে লোড হয়।
• FetchType.EAGER: ডেটা লোডিংয়ের সময় সব সম্পর্কিত ডেটাও লোড হয়।

সারাংশ

Spring Boot ORM-এ Entity Relationships ডাটাবেস টেবিলের সম্পর্কগুলোকে Java অবজেক্টে ম্যাপ করার একটি সহজ ও কার্যকর উপায়।

• One-to-One: একটি Entity-এর সাথে একটি Entity।
• One-to-Many: একটি Entity-এর সাথে একাধিক Entity।
• Many-to-Many: একাধিক Entity-এর সাথে একাধিক Entity।

এই সম্পর্কগুলো সঠিকভাবে ব্যবহার করে ডাটাবেস ডেটা ম্যানেজমেন্টকে সহজতর করা যায়।

স্প্রিং বুট ORM (Object-Relational Mapping) ব্যবহার করার সময় ডেটাবেস টেবিলগুলোর মধ্যে সম্পর্ক স্থাপন করার জন্য Entity Relationship খুব গুরুত্বপূর্ণ। Entity Relationship বিভিন্ন ডেটাবেস টেবিল এবং তাদের মধ্যে থাকা সম্পর্কগুলো জাভা ক্লাসের মাধ্যমে প্রকাশ করে।

Entity Relationship এর ধরন

ডেটাবেসে সাধারণত তিন ধরণের সম্পর্ক থাকে, এবং এগুলো Entity Relationship এর মাধ্যমে স্প্রিং বুট ORM-এ প্রকাশ করা হয়:

১. One-to-One (১:১ সম্পর্ক)

একটি টেবিলের একটি রেকর্ড আরেকটি টেবিলের একটি রেকর্ডের সাথে সম্পর্কযুক্ত থাকে।

২. One-to-Many এবং Many-to-One (১:একাধিক এবং একাধিক:১ সম্পর্ক)

একটি টেবিলের একটি রেকর্ড আরেকটি টেবিলের একাধিক রেকর্ডের সাথে সম্পর্কযুক্ত থাকে।

৩. Many-to-Many (একাধিক:একাধিক সম্পর্ক)

একটি টেবিলের একাধিক রেকর্ড আরেকটি টেবিলের একাধিক রেকর্ডের সাথে সম্পর্কযুক্ত থাকে।

স্প্রিং বুটে Entity Relationship এর অ্যানোটেশন

Spring Boot ORM (Hibernate) এ Entity Relationship প্রকাশ করার জন্য নিম্নলিখিত অ্যানোটেশনগুলো ব্যবহার করা হয়:

• @OneToOne
• @OneToMany
• @ManyToOne
• @ManyToMany
• @JoinColumn
• @JoinTable

Entity Relationship এর উদাহরণ

১. One-to-One সম্পর্ক

একজন ব্যবহারকারীর একটি প্রোফাইল থাকতে পারে।

import jakarta.persistence.*;

@Entity
public class User {

    @Id
    @GeneratedValue
    private Long id;

    private String name;

    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "profile_id", referencedColumnName = "id")
    private Profile profile;

    // Getters and Setters
}

@Entity
public class Profile {

    @Id
    @GeneratedValue
    private Long id;

    private String bio;

    // Getters and Setters
}

ব্যাখ্যা:

• @OneToOne: User এবং Profile এর মধ্যে ১:১ সম্পর্ক স্থাপন করে।
• @JoinColumn: User টেবিলে profile_id কলাম যোগ করে যা Profile টেবিলের id কলামের সাথে যুক্ত।

২. One-to-Many এবং Many-to-One সম্পর্ক

একজন লেখকের অনেক বই থাকতে পারে।

import jakarta.persistence.*;
import java.util.List;

@Entity
public class Author {

    @Id
    @GeneratedValue
    private Long id;

    private String name;

    @OneToMany(mappedBy = "author", cascade = CascadeType.ALL)
    private List<Book> books;

    // Getters and Setters
}

@Entity
public class Book {

    @Id
    @GeneratedValue
    private Long id;

    private String title;

    @ManyToOne
    @JoinColumn(name = "author_id", referencedColumnName = "id")
    private Author author;

    // Getters and Setters
}

ব্যাখ্যা:

• @OneToMany: একজন লেখকের একাধিক বইয়ের সম্পর্ক নির্দেশ করে।
• @ManyToOne: একটি বইয়ের সাথে শুধুমাত্র একজন লেখকের সম্পর্ক নির্দেশ করে।
• mappedBy: Author-এর books ফিল্ড Book Entity-তে সম্পর্ক স্থাপন করে।

৩. Many-to-Many সম্পর্ক

একজন শিক্ষার্থী একাধিক কোর্সে ভর্তি হতে পারে, এবং একটি কোর্সে একাধিক শিক্ষার্থী থাকতে পারে।

import jakarta.persistence.*;
import java.util.Set;

@Entity
public class Student {

    @Id
    @GeneratedValue
    private Long id;

    private String name;

    @ManyToMany
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private Set<Course> courses;

    // Getters and Setters
}

@Entity
public class Course {

    @Id
    @GeneratedValue
    private Long id;

    private String title;

    @ManyToMany(mappedBy = "courses")
    private Set<Student> students;

    // Getters and Setters
}

ব্যাখ্যা:

• @ManyToMany: Student এবং Course এর মধ্যে একাধিক:একাধিক সম্পর্ক নির্দেশ করে।
• @JoinTable: সম্পর্কের জন্য একটি মধ্যবর্তী টেবিল (student_course) তৈরি করে।
• mappedBy: Student-এর courses ফিল্ড এবং Course-এর students ফিল্ডের মধ্যে সম্পর্ক নির্দেশ করে।

Cascade এবং Fetch টাইপ

Entity Relationship এর ক্ষেত্রে Cascade এবং Fetch গুরুত্বপূর্ণ ভূমিকা পালন করে।

Cascade

• Cascade টাইপ (যেমন ALL, PERSIST, REMOVE) ব্যবহার করে সংযুক্ত Entity-তে নির্দিষ্ট অপারেশন প্রযোজ্য করা যায়।

Fetch

• Fetch টাইপ (যেমন LAZY, EAGER) ব্যবহার করে ডেটা লোডিং স্ট্র্যাটেজি নির্ধারণ করা হয়।

সারাংশ

Spring Boot ORM এ Entity Relationship বিভিন্ন টেবিলের মধ্যে সম্পর্ক স্থাপন করে ডেটা মডেলিং সহজ করে। @OneToOne, @OneToMany, @ManyToOne, এবং @ManyToMany অ্যানোটেশন ব্যবহার করে ডেটাবেস টেবিলের মধ্যে সম্পর্ক নির্ধারণ করা যায়। এই সম্পর্কগুলোর মাধ্যমে ডেটাবেস অপারেশন আরও কার্যকর এবং পুনঃব্যবহারযোগ্য হয়।

স্প্রিং বুট ORM (Hibernate/JPA) ব্যবহার করে ডেটাবেসের টেবিলের মধ্যে সম্পর্ক (Relationship) তৈরি করা যায়। JPA অ্যানোটেশন যেমন @OneToOne, @OneToMany, এবং @ManyToMany ব্যবহার করে এই সম্পর্কগুলি সহজেই সংজ্ঞায়িত করা যায়।

One-to-One Mapping

একটি টেবিলের একটি রেকর্ড অন্য একটি টেবিলের কেবল একটি রেকর্ডের সাথে সম্পর্কিত থাকে।
উদাহরণ: একজন ব্যবহারকারীর শুধুমাত্র একটি প্রোফাইল থাকতে পারে।

@OneToOne অ্যানোটেশন ব্যবহারের ধাপ:

Entity ক্লাস উদাহরণ:

import jakarta.persistence.*;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "profile_id", referencedColumnName = "id")
    private Profile profile;

    // Getters and Setters
}

@Entity
public class Profile {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String bio;

    // Getters and Setters
}

বুঝিয়ে বলি:

• @OneToOne: User এবং Profile টেবিলের মধ্যে এক থেকে এক সম্পর্ক স্থাপন করে।
• @JoinColumn: User টেবিলের profile_id কলামটিকে Profile টেবিলের id কলামের সাথে ম্যাপ করে।

One-to-Many Mapping

একটি টেবিলের একটি রেকর্ড অন্য একটি টেবিলের একাধিক রেকর্ডের সাথে সম্পর্কিত থাকে।
উদাহরণ: একটি ক্যাটাগরিতে একাধিক পণ্য থাকতে পারে।

@OneToMany অ্যানোটেশন ব্যবহারের ধাপ:

Entity ক্লাস উদাহরণ:

import jakarta.persistence.*;
import java.util.List;

@Entity
public class Category {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToMany(mappedBy = "category", cascade = CascadeType.ALL)
    private List<Product> products;

    // Getters and Setters
}

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @ManyToOne
    @JoinColumn(name = "category_id", referencedColumnName = "id")
    private Category category;

    // Getters and Setters
}

বুঝিয়ে বলি:

• @OneToMany: একটি ক্যাটাগরিতে একাধিক পণ্য সম্পর্কিত।
• mappedBy: Product টেবিলের category ফিল্ডের মাধ্যমে সম্পর্কটি সংজ্ঞায়িত করে।
• @ManyToOne: Product টেবিল থেকে Category টেবিলের সাথে সম্পর্ক স্থাপন করে।

Many-to-Many Mapping

একটি টেবিলের একাধিক রেকর্ড অন্য একটি টেবিলের একাধিক রেকর্ডের সাথে সম্পর্কিত থাকে।
উদাহরণ: একজন ছাত্র একাধিক কোর্স নিতে পারে এবং একটি কোর্সে একাধিক ছাত্র থাকতে পারে।

@ManyToMany অ্যানোটেশন ব্যবহারের ধাপ:

Entity ক্লাস উদাহরণ:

import jakarta.persistence.*;
import java.util.List;

@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @ManyToMany
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private List<Course> courses;

    // Getters and Setters
}

@Entity
public class Course {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String title;

    @ManyToMany(mappedBy = "courses")
    private List<Student> students;

    // Getters and Setters
}

বুঝিয়ে বলি:

• @ManyToMany: Student এবং Course টেবিলের মধ্যে একাধিক থেকে একাধিক সম্পর্ক স্থাপন করে।
• @JoinTable: একটি মধ্যবর্তী টেবিল (student_course) তৈরি করে, যেখানে student_id এবং course_id সংরক্ষিত থাকে।
• inverseJoinColumns: বিপরীত সম্পর্কের কলাম সংজ্ঞায়িত করে।

Cascade এবং Fetch টাইপ

• Cascade: ডেটা সঞ্চালনের সময় সম্পর্কিত টেবিলের উপর স্বয়ংক্রিয় অপারেশন করে। উদাহরণ: CascadeType.ALL, CascadeType.PERSIST, CascadeType.REMOVE।
• Fetch Type: ডেটা লোড করার সময় সম্পর্কিত ডেটা কীভাবে ফেচ করা হবে তা নির্ধারণ করে। উদাহরণ: FetchType.LAZY (ডেটা প্রয়োজন হলে লোড হবে), FetchType.EAGER (প্রথমে সব ডেটা লোড হবে)।

উদাহরণ:

@OneToMany(mappedBy = "category", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private List<Product> products;

সারাংশ

স্প্রিং বুট ORM-এ @OneToOne, @OneToMany, এবং @ManyToMany অ্যানোটেশন ব্যবহার করে ডেটাবেস সম্পর্ক সহজে সংজ্ঞায়িত করা যায়। এই সম্পর্কগুলো ব্যবহারের মাধ্যমে ডেটাবেস অপারেশন যেমন টেবিল ম্যাপিং, ডেটা রিলেশন, এবং CRUD অপারেশন খুবই কার্যকরী ও সহজ হয়।

স্প্রিং বুট ORM-এ Cascade এবং Fetch Type হলো JPA এর গুরুত্বপূর্ণ ফিচার, যা ডাটাবেস সম্পর্ক (Database Relationships) পরিচালনা করতে ব্যবহৃত হয়। এগুলো Parent এবং Child Entity এর মধ্যে সম্পর্ক এবং ডেটা ফেচিং কৌশল নির্ধারণ করতে সাহায্য করে।

Cascade টাইপ

Cascade নির্ধারণ করে Parent Entity-তে ডেটা অপারেশন করার সময় তা Child Entity-তে কীভাবে প্রভাব ফেলবে। উদাহরণস্বরূপ, যদি Parent Entity-তে একটি অপারেশন চালানো হয় (যেমন: সেভ, ডিলিট), তবে সেই অপারেশন Child Entity-তেও স্বয়ংক্রিয়ভাবে প্রয়োগ করা হবে।

Cascade টাইপসমূহ

1. CascadeType.PERSIST: Parent Entity সেভ করার সময় Child Entity-ও সেভ হয়।
2. CascadeType.MERGE: Parent Entity মুডিফাই করার সময় Child Entity-ও মুডিফাই হয়।
3. CascadeType.REMOVE: Parent Entity মুছে ফেলার সময় Child Entity-ও মুছে যায়।
4. CascadeType.REFRESH: Parent Entity রিফ্রেশ করলে Child Entity-ও রিফ্রেশ হয়।
5. CascadeType.DETACH: Parent Entity আলাদা করলে Child Entity-ও আলাদা হয়।
6. CascadeType.ALL: উপরোক্ত সব অপারেশন Parent এবং Child উভয় Entity-তে প্রয়োগ হয়।

উদাহরণ

import jakarta.persistence.*;
import java.util.List;

@Entity
public class Department {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToMany(mappedBy = "department", cascade = CascadeType.ALL)
    private List<Employee> employees;

    // Getter এবং Setter
}

@Entity
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @ManyToOne
    @JoinColumn(name = "department_id")
    private Department department;

    // Getter এবং Setter
}

উপরের কোডে, CascadeType.ALL ব্যবহার করা হয়েছে। ফলে, যদি একটি Department সেভ বা ডিলিট করা হয়, তবে সংশ্লিষ্ট Employee গুলোতেও সেই অপারেশন প্রয়োগ হবে।

Fetch Type

Fetch Type Parent এবং Child Entity-এর মধ্যে সম্পর্কিত ডেটা কীভাবে ডাটাবেস থেকে রিট্রিভ করা হবে তা নির্ধারণ করে। এটি দুই প্রকারের হতে পারে:

1. FetchType.EAGER: সম্পর্কিত ডেটা সঙ্গে সঙ্গে লোড হয়।
2. FetchType.LAZY: সম্পর্কিত ডেটা তখনই লোড হয় যখন তা দরকার।

উদাহরণ

@Entity
public class Department {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToMany(mappedBy = "department", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    private List<Employee> employees;

    // Getter এবং Setter
}

• FetchType.LAZY: ডিফল্ট মান। এখানে employees কেবল তখনই লোড হবে, যখন এটি স্পেসিফিক্যালি অ্যাক্সেস করা হবে।
• FetchType.EAGER: Parent Entity লোড করার সময় Child Entity-ও স্বয়ংক্রিয়ভাবে লোড হবে।

@OneToMany(mappedBy = "department", fetch = FetchType.EAGER, cascade = CascadeType.ALL)

Cascade এবং FetchType এর সংমিশ্রণ

কিছু পরিস্থিতিতে Cascade এবং Fetch Type একসঙ্গে ব্যবহার করা হয়। উদাহরণস্বরূপ:

@Entity
public class Department {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToMany(mappedBy = "department", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    private List<Employee> employees;

    // Getter এবং Setter
}

এখানে:

• CascadeType.ALL নিশ্চিত করে যে Parent Entity-তে অপারেশন করলে Child Entity-তেও তা প্রভাব ফেলবে।
• FetchType.EAGER নিশ্চিত করে যে employees সম্পর্কিত ডেটা Parent Entity লোড করার সময়ই রিট্রিভ হবে।

বাস্তব জীবনের ব্যবহারের উদাহরণ

EAGER Fetch এর ব্যবহার

EAGER Fetch Type ব্যবহার করা হয় যখন Parent Entity-র সাথে Child Entity-র ডেটা প্রায়ই ব্যবহার করা হয়।

LAZY Fetch এর ব্যবহার

LAZY Fetch Type তখন ব্যবহার করা হয় যখন Child Entity-র ডেটা কেবল প্রয়োজনীয় সময়ে লোড করতে চাই।

CascadeType.ALL এর ব্যবহার

CascadeType.ALL ব্যবহার করা হয় যখন Parent এবং Child Entity-র মধ্যে অপারেশন একসঙ্গে পরিচালনা করতে হয়।

সারাংশ

• Cascade Parent এবং Child Entity-র মধ্যে অপারেশনের প্রভাব নির্ধারণ করে।
• Fetch Type Parent এবং Child Entity-র মধ্যে ডেটা লোডিং কৌশল নির্ধারণ করে।
• সঠিকভাবে Cascade এবং Fetch Type কনফিগারেশন করার মাধ্যমে ডাটাবেস অপারেশন এবং পারফরম্যান্স উন্নত করা যায়।

Entity Relationship Mapping (ERM) হলো Spring Boot ORM-এর মাধ্যমে একাধিক Entity এর মধ্যে সম্পর্ক স্থাপন করার প্রক্রিয়া। এটি ডেটাবেস টেবিলের সম্পর্ক যেমন One-to-One, One-to-Many, Many-to-One, এবং Many-to-Many কে Entity ক্লাসের মধ্যে মডেলিং করতে ব্যবহৃত হয়।

Entity Relationship Mapping-এর ধরন

One-to-One

একটি Entity-এর সাথে অন্য একটি Entity-এর এক-এক সম্পর্ক থাকে।

One-to-Many / Many-to-One

একটি Entity অনেকগুলো Entity এর সাথে সম্পর্কিত থাকতে পারে, কিন্তু অন্য Entity একটি মাত্র Entity এর সাথে সম্পর্কিত।

Many-to-Many

একাধিক Entity একে অপরের সাথে একাধিক সম্পর্কিত হতে পারে।

উদাহরণ: Entity Relationship Mapping

নিচে Employee এবং Department এর মধ্যে One-to-Many সম্পর্ক এবং Project এর সাথে Many-to-Many সম্পর্ক দেখানো হয়েছে।

Entity: Department

import jakarta.persistence.*;
import java.util.List;

@Entity
public class Department {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @OneToMany(mappedBy = "department", cascade = CascadeType.ALL)
    private List<Employee> employees;

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Employee> getEmployees() {
        return employees;
    }

    public void setEmployees(List<Employee> employees) {
        this.employees = employees;
    }
}

Entity: Employee

import jakarta.persistence.*;
import java.util.Set;

@Entity
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @ManyToOne
    @JoinColumn(name = "department_id")
    private Department department;

    @ManyToMany
    @JoinTable(
        name = "employee_project",
        joinColumns = @JoinColumn(name = "employee_id"),
        inverseJoinColumns = @JoinColumn(name = "project_id")
    )
    private Set<Project> projects;

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Department getDepartment() {
        return department;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }

    public Set<Project> getProjects() {
        return projects;
    }

    public void setProjects(Set<Project> projects) {
        this.projects = projects;
    }
}

Entity: Project

import jakarta.persistence.*;
import java.util.Set;

@Entity
public class Project {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String projectName;

    @ManyToMany(mappedBy = "projects")
    private Set<Employee> employees;

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getProjectName() {
        return projectName;
    }

    public void setProjectName(String projectName) {
        this.projectName = projectName;
    }

    public Set<Employee> getEmployees() {
        return employees;
    }

    public void setEmployees(Set<Employee> employees) {
        this.employees = employees;
    }
}

টেবিল স্কিমা (Database Schema)

Spring Boot চালু করার পর Hibernate নিম্নোক্ত টেবিলগুলো তৈরি করবে:

1. Department Table

   CREATE TABLE department (
       id BIGINT AUTO_INCREMENT PRIMARY KEY,
       name VARCHAR(255)
   );
   

2. Employee Table

   CREATE TABLE employee (
       id BIGINT AUTO_INCREMENT PRIMARY KEY,
       name VARCHAR(255),
       department_id BIGINT,
       FOREIGN KEY (department_id) REFERENCES department(id)
   );
   

3. Project Table

   CREATE TABLE project (
       id BIGINT AUTO_INCREMENT PRIMARY KEY,
       project_name VARCHAR(255)
   );
   

4. Employee_Project Join Table

   CREATE TABLE employee_project (
       employee_id BIGINT,
       project_id BIGINT,
       PRIMARY KEY (employee_id, project_id),
       FOREIGN KEY (employee_id) REFERENCES employee(id),
       FOREIGN KEY (project_id) REFERENCES project(id)
   );
   

REST API উদাহরণ

EmployeeController

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/employees")
public class EmployeeController {

    @Autowired
    private EmployeeRepository employeeRepository;

    @GetMapping
    public List<Employee> getAllEmployees() {
        return employeeRepository.findAll();
    }

    @PostMapping
    public Employee createEmployee(@RequestBody Employee employee) {
        return employeeRepository.save(employee);
    }
}

উপসংহার

Entity Relationship Mapping এর মাধ্যমে ডেটাবেস টেবিলের মধ্যে সম্পর্ক Spring Boot এবং JPA ব্যবহার করে সহজে মডেল করা যায়। এটি ডেটাবেস অপারেশনকে আরও সংগঠিত, দ্রুত এবং উন্নত করে। @OneToOne, @OneToMany, @ManyToOne, এবং @ManyToMany অ্যানোটেশন ব্যবহার করে সম্পর্ক গঠন করা যায়।